home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-04 / ddj1191.zip / DEVLOD.ZIP / DEVLOD.C < prev    next >
C/C++ Source or Header  |  1990-09-25  |  13KB  |  358 lines
  1. /********************************************************************
  2.  *     DEVLOD.C - Jim Kyle - 08/20/90                               *
  3.  *            Copyright 1990 by Jim Kyle - All Rights Reserved      *
  4.  *     (minor revisions by Andrew Schulman - 9/12/90                *
  5.  *     Dynamic loader for device drivers                            *
  6.  *            Requires Turbo C; see DEVLOD.MAK also for ASM helpers.*
  7.  ********************************************************************/
  8.      
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <dos.h>
  12.  
  13. typedef unsigned char BYTE;
  14.  
  15. #define GETFLAGS __emit__(0x9F)     /* if any error, quit right now */
  16. #define FIXDS    __emit__(0x16,0x1F)/* PUSH SS, POP DS              */
  17. #define PUSH_BP  __emit__(0x55)
  18. #define POP_BP   __emit__(0x5D)
  19.  
  20. unsigned _stklen = 0x200;
  21. unsigned _heaplen = 0;
  22.  
  23. char FileName[65];  /* filename global buffer                       */
  24. char * dvrarg;      /* points to char after name in cmdline buffer  */
  25. unsigned movsize;   /* number of bytes to be moved up for driver    */
  26. void (far * driver)();  /* used as pointer to call driver code      */
  27. void far * drvptr;  /* holds pointer to device driver               */
  28. void far * nuldrvr; /* additional driver pointers                   */
  29. void far * nxtdrvr;
  30. BYTE far * nblkdrs; /* points to block device count in List of Lists*/
  31. unsigned lastdrive; /* value of LASTDRIVE in List of Lists          */
  32. BYTE far * CDSbase; /* base of Current Dir Structure                */
  33. int CDSsize;        /* size of CDS element                          */
  34. unsigned nulseg;    /* hold parts of ListOfLists pointer            */
  35. unsigned nulofs;
  36. unsigned LoLofs;
  37.  
  38. #pragma pack(1)
  39.  
  40. struct packet{      /* device driver's command packet               */
  41.     BYTE hdrlen;
  42.     BYTE unit;
  43.     BYTE command;       /* 0 to initialize      */
  44.     unsigned status;    /* 0x8000 is error      */
  45.     BYTE reserv[8];
  46.     BYTE nunits;
  47.     unsigned brkofs;    /* break adr on return  */
  48.     unsigned brkseg;    /* break seg on return  */
  49.     unsigned inpofs;    /* SI on input          */
  50.     unsigned inpseg;    /* _psp on input        */
  51.     BYTE NextDrv;       /* next available drive */
  52.   } CmdPkt;
  53.   
  54. typedef struct {    /* Current Directory Structure (CDS)            */
  55.     BYTE path[0x43];
  56.     unsigned flags;
  57.     void far *dpb;
  58.     unsigned start_cluster;
  59.     unsigned long ffff;
  60.     unsigned slash_offset;  /* offset of '\' in current path field  */
  61.     // next for DOS4+ only
  62.     BYTE unknown;
  63.     void far *ifs;
  64.     unsigned unknown2;
  65.     } CDS;
  66.  
  67. extern unsigned _psp;       /* established by startup code in c0    */
  68. extern unsigned _heaptop;   /* established by startup code in c0    */
  69. extern BYTE _osmajor;       /* established by startup code      */
  70. extern BYTE _osminor;       /* established by startup code      */
  71.  
  72. void _exit( int );          /* established by startup code in c0    */
  73. void abort( void );         /* established by startup code in c0    */
  74.  
  75. void movup( char far *, char far *, int ); /* in MOVUP.ASM file     */
  76. void copyptr( void far *src, void far *dst ); /* in MOVUP.ASM file  */
  77.  
  78. void exit(int c)            /* called by startup code's sequence    */
  79. { _exit(c);}
  80.  
  81. int Get_Driver_Name ( void )
  82. { char *nameptr;
  83.   int i, j, cmdlinesz;
  84.  
  85.   nameptr = (char *)0x80;   /* check command line for driver name   */
  86.   cmdlinesz = (unsigned)*nameptr++;
  87.   if (cmdlinesz < 1)        /* if nothing there, return FALSE       */
  88.     return 0;
  89.   for (i=0; i<cmdlinesz && nameptr[i]<'!'; i++) /* skip blanks      */
  90.     ;
  91.   dvrarg = (char *)&nameptr[i]; /* save to put in SI                */
  92.   for ( j=0; i<cmdlinesz && nameptr[i]>' '; i++)    /* copy name    */
  93.     FileName[j++] = nameptr[i];
  94.   FileName[j] = '\0';
  95.  
  96.   return 1;                 /* and return TRUE to keep going        */
  97. }
  98.  
  99. void Put_Msg ( char *msg )  /* replaces printf()                    */
  100. { 
  101. #ifdef INT29
  102.     /* gratuitous use of undocumented DOS */
  103.     while (*msg)
  104.     { _AL = *msg++;             /* MOV AL,*msg  */
  105.       geninterrupt(0x29);       /* INT 29h */
  106.     }
  107. #else
  108.     _AH = 2;    /* doesn't need to be inside loop */
  109.     while (*msg)
  110.     { _DL = *msg++;            
  111.       geninterrupt(0x21);
  112.     }
  113. #endif
  114. }
  115.  
  116. void Err_Halt ( char *msg )     /* print message and abort          */
  117. { Put_Msg ( msg );
  118.   Put_Msg ( "\r\n" );           /* send CR,LF   */
  119.   abort();
  120. }
  121.  
  122. void Move_Loader ( void )       /* vacate lower part of RAM         */
  123. {
  124.     unsigned movsize, destseg;
  125.     movsize = _heaptop - _psp; /* size of loader in paragraphs      */
  126.     destseg = *(unsigned far *)MK_FP( _psp, 2 ); /* end of memory   */
  127.     movup ( MK_FP( _psp, 0 ), MK_FP( destseg - movsize, 0 ),
  128.             movsize << 4);      /* move and fix segregs             */
  129. }
  130.  
  131. void Load_Drvr ( void )         /* load driver file into RAM    */
  132. { unsigned handle;
  133.   struct {
  134.     unsigned LoadSeg;
  135.     unsigned RelocSeg;
  136.   } ExecBlock;
  137.  
  138.   ExecBlock.LoadSeg = _psp + 0x10;
  139.   ExecBlock.RelocSeg = _psp + 0x10;
  140.   _DX = (unsigned)&FileName[0];
  141.   _BX = (unsigned)&ExecBlock;
  142.   _ES = _SS;                    /* es:bx point to ExecBlock     */
  143.   _AX = 0x4B03;                 /* load overlay                 */
  144.   geninterrupt ( 0x21 );        /* DS is okay on this call      */
  145.   GETFLAGS;
  146.   if ( _AH & 1 )
  147.     Err_Halt ( "Unable to load driver file." );
  148. }
  149.  
  150. void Get_List ( void )          /* set up pointers via List     */
  151. { _AH = 0x52;                   /* find DOS List of Lists       */
  152.   geninterrupt ( 0x21 );
  153.   nulseg = _ES;                 /* DOS data segment             */
  154.   LoLofs = _BX;                 /* current drive table offset   */
  155.  
  156.   switch( _osmajor )            /* NUL adr varies with version  */
  157.     {
  158.     case  0:
  159.       Err_Halt ( "Drivers not used in DOS V1." );
  160.     case  2:
  161.       nblkdrs = NULL;
  162.       nulofs = LoLofs + 0x17;
  163.       break;
  164.     case  3:
  165.       if (_osminor == 0)
  166.       {
  167.           nblkdrs = (BYTE far *) MK_FP(nulseg, LoLofs + 0x10);
  168.           lastdrive = *((BYTE far *) MK_FP(nulseg, LoLofs + 0x1b));
  169.           nulofs = LoLofs + 0x28;
  170.       }
  171.       else
  172.       {
  173.           nblkdrs = (BYTE far *) MK_FP(nulseg, LoLofs + 0x20);
  174.           lastdrive = *((BYTE far *) MK_FP(nulseg, LoLofs + 0x21));
  175.           nulofs = LoLofs + 0x22;
  176.       }
  177.       CDSbase = *(BYTE far * far *)MK_FP(nulseg, LoLofs + 0x16);
  178.       CDSsize = 81;
  179.       break;
  180.     case  4:
  181.     case  5:
  182.       nblkdrs = (BYTE far *) MK_FP(nulseg, LoLofs + 0x20);
  183.       lastdrive = *((BYTE far *) MK_FP(nulseg, LoLofs + 0x21));
  184.       nulofs  = LoLofs + 0x22;
  185.       CDSbase = *(BYTE far * far *) MK_FP(nulseg, LoLofs + 0x16);
  186.       CDSsize = 88;
  187.       break;
  188.     case 10:
  189.     case 20:
  190.       Err_Halt ( "OS2 DOS Box not supported." );
  191.     default:
  192.       Err_Halt ( "Unknown version of DOS!");
  193.     }
  194. }
  195.  
  196. void Fix_DOS_Chain ( void )     /* patches driver into DOS chn  */
  197. { unsigned i;
  198.  
  199.   nuldrvr = MK_FP( nulseg, nulofs+0x0A ); /* verify the drvr    */
  200.   drvptr = "NUL     ";
  201.   for ( i=0; i<8; ++i )
  202.     if ( *((BYTE far *)nuldrvr+i) != *((BYTE far *)drvptr+i) )
  203.       Err_Halt ( "Failed to find NUL driver." );
  204.  
  205.   nuldrvr = MK_FP( nulseg, nulofs );    /* point to NUL driver  */
  206.   drvptr  = MK_FP( _psp+0x10, 0 );      /* new driver's address */
  207.  
  208.   copyptr ( nuldrvr, &nxtdrvr );        /* hold old head now    */
  209.   copyptr ( &drvptr, nuldrvr );         /* put new after NUL    */
  210.   copyptr ( &nxtdrvr, drvptr );         /* and old after new    */
  211. }
  212.  
  213. // returns number of next free drive, -1 if none available
  214. int Next_Drive ( void )
  215. {
  216. #ifdef USE_BLKDEV
  217.   return (nblkdrs && (*nblkdrs < lastdrive)) ? *nblkdrs : -1;
  218. #else
  219.   /* The following approach takes account of SUBSTed and
  220.      network-redirector drives */
  221.   CDS far *cds;
  222.   int i;
  223.   /* find first unused entry in CDS structure */
  224.   for (i=0, cds=CDSbase; i<lastdrive; i++, ((BYTE far *)cds)+=CDSsize)
  225.     if (! cds->flags)                /* found a free drive  */
  226.         break;
  227.   return (i == lastdrive) ? -1 : i; 
  228. #endif  
  229. }
  230.  
  231. int Init_Drvr ( void )
  232. { unsigned tmp;
  233. #define INIT 0
  234.   CmdPkt.command = INIT;        /* build command packet         */
  235.   CmdPkt.hdrlen = sizeof (struct packet);
  236.   CmdPkt.unit = 0;
  237.   CmdPkt.inpofs  = (unsigned)dvrarg;    /* points into cmd line */
  238.   CmdPkt.inpseg  = _psp;
  239.   /* can't really check for next drive here, because don't yet know
  240.      if this is a block driver or not */
  241.   CmdPkt.NextDrv = Next_Drive();
  242.   drvptr  = MK_FP( _psp+0x10, 0 );      /* new driver's address */
  243.  
  244.   tmp = *((unsigned far *)drvptr+3);    /* STRATEGY pointer     */
  245.   driver = MK_FP( FP_SEG( drvptr ), tmp );
  246.   _ES = FP_SEG( (void far *)&CmdPkt );
  247.   _BX = FP_OFF( (void far *)&CmdPkt );
  248.   (*driver)();                  /* set up the packet address    */
  249.  
  250.   tmp = *((unsigned far *)drvptr+4);    /* COMMAND pointer      */
  251.   driver = MK_FP( FP_SEG( drvptr ), tmp );
  252.   (*driver)();                  /* do the initialization        */
  253.   
  254.   /* check status code in command packet                        */
  255.   return (! ( CmdPkt.status & 0x8000 ));
  256. }
  257.  
  258. int  Put_Blk_Dev ( void )   /* TRUE if Block Device failed      */
  259. { int newdrv;
  260.   int retval = 1;           /* pre-set for failure              */
  261.   int unit = 0;
  262.   BYTE far *DPBlink;
  263.   CDS far *cds;
  264.   int i;
  265.  
  266.   if ((Next_Drive() == -1) || CmdPkt.nunits == 0)
  267.     return retval;          /* cannot install block driver      */
  268.   if (CmdPkt.brkofs != 0)   /* align to next paragraph          */
  269.   {
  270.     CmdPkt.brkseg += (CmdPkt.brkofs >> 4) + 1;
  271.     CmdPkt.brkofs = 0;
  272.   }
  273.   while( CmdPkt.nunits-- )
  274.   {
  275.     if ((newdrv = Next_Drive()) == -1)
  276.         return 1;
  277.     (*nblkdrs)++;
  278.     _AH = 0x32;             /* get last DPB and set poiner      */
  279.     _DL = newdrv;
  280.     geninterrupt ( 0x21 );
  281.     _AX = _DS;              /* save segment to make the pointer */
  282.     FIXDS;
  283.     DPBlink = MK_FP(_AX, _BX);
  284.     (unsigned) DPBlink += (_osmajor < 4 ? 24 : 25 );
  285.     _SI = *(unsigned far *)MK_FP(CmdPkt.inpseg, CmdPkt.inpofs);
  286.     _ES = CmdPkt.brkseg;
  287.     _DS = CmdPkt.inpseg;
  288.     _AH = 0x53;
  289.     PUSH_BP;
  290.     _BP = 0;
  291.     geninterrupt ( 0x21 );    /* build the DPB for this unit    */
  292.     POP_BP;
  293.     FIXDS;
  294.     *(void far * far *)DPBlink = MK_FP( CmdPkt.brkseg, 0 );
  295.  
  296.     /* set up the Current Directory Structure for this drive */
  297.     cds = (CDS far *) (CDSbase + (newdrv * CDSsize));
  298.     cds->flags = 1 << 14;       /* PHYSICAL DRIVE */
  299.     cds->dpb = MK_FP(CmdPkt.brkseg, 0);
  300.     cds->start_cluster = 0xFFFF;
  301.     cds->ffff = -1L;
  302.     cds->slash_offset = 2;
  303.     if (_osmajor > 3)
  304.       { cds->unknown = 0;
  305.         cds->ifs = (void far *) 0;
  306.         cds->unknown2 = 0;
  307.       }
  308.       
  309.     /* set up pointers for DPB, driver  */
  310.     DPBlink = MK_FP( CmdPkt.brkseg, 0);
  311.     *DPBlink = newdrv;
  312.     *(DPBlink+1) = unit++;
  313.     if (_osmajor > 3)
  314.       DPBlink++;          /* add one if DOS 4                 */
  315.     *(long far *)(DPBlink+0x12) = (long)MK_FP( _psp+0x10, 0 );
  316.     *(long far *)(DPBlink+0x18) = 0xFFFFFFFF;
  317.     CmdPkt.brkseg += 2;       /* Leave two paragraphs for DPB   */
  318.     CmdPkt.inpofs += 2;       /* Point to next BPB pointer      */
  319.   }     /* end of nunits loop   */
  320.   return 0;                 /* all went okay                    */
  321. }
  322.  
  323. void Get_Out ( void )
  324. { unsigned temp;
  325.  
  326.   temp = *((unsigned far *)drvptr+2);   /* attribute word       */
  327.   if ((temp & 0x8000) == 0 )    /* if block device, set up tbls */
  328.     if (Put_Blk_Dev() )
  329.       Err_Halt( "Could not install block device" );
  330.  
  331.   Fix_DOS_Chain ();             /* else patch it into DOS       */
  332.  
  333.   _ES = *((unsigned *)MK_FP( _psp, 0x002C ));
  334.   _AH = 0x49;                   /* release environment space    */
  335.   geninterrupt ( 0x21 );
  336.  
  337.   /* then set up regs for KEEP function, and go resident        */
  338.   temp = (CmdPkt.brkofs + 15);  /* normalize the offset         */
  339.   temp >>= 4;
  340.   temp += CmdPkt.brkseg;        /* add the segment address      */
  341.   temp -= _psp;                 /* convert to paragraph count   */
  342.   _AX = 0x3100;                 /* KEEP function of DOS         */
  343.   _DX = (unsigned)temp;         /* paragraphs to retain         */
  344.   geninterrupt ( 0x21 );        /* won't come back from here!   */
  345. }
  346.  
  347. void main ( void )
  348. { if (!Get_Driver_Name() )
  349.     Err_Halt ( "Device driver name required.");
  350.   Move_Loader ();               /* move code high and jump      */
  351.   Load_Drvr ();                 /* bring driver into freed RAM  */
  352.   Get_List();                   /* get DOS internal variables   */
  353.   if (Init_Drvr ())             /* let driver do its thing      */
  354.       Get_Out();                /* check init status, go TSR    */
  355.   else
  356.       Err_Halt ( "Driver initialization failed." );
  357. }
  358.